package com.example.myblog.service;

import org.commonmark.node.Node;
import org.commonmark.parser.Parser;
import org.commonmark.renderer.html.HtmlRenderer;
import org.commonmark.renderer.text.TextContentRenderer;
import org.commonmark.ext.gfm.tables.TablesExtension;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;

/**
 * Markdown处理服务，用于将Markdown格式转换为HTML
 */
@Service
public class MarkdownService {

    private final Parser parser;
    private final HtmlRenderer renderer;
    private final TextContentRenderer textRenderer;
    
    /**
     * 构造函数，初始化Parser和Renderer
     */
    public MarkdownService() {
        // 启用表格扩展
        List<org.commonmark.Extension> extensions = Arrays.asList(TablesExtension.create());
        parser = Parser.builder().extensions(extensions).build();
        renderer = HtmlRenderer.builder().extensions(extensions).build();
        textRenderer = TextContentRenderer.builder().extensions(extensions).build();
    }
    
    /**
     * 将Markdown文本转换为HTML
     * 
     * @param markdown Markdown格式的文本
     * @return 转换后的HTML文本
     */
    public String convertToHtml(String markdown) {
        if (markdown == null || markdown.isEmpty()) {
            return "";
        }
        
        Node document = parser.parse(markdown);
        return renderer.render(document);
    }
    
    /**
     * 将Markdown文本转换为纯文本摘要
     * 去除所有Markdown格式符号，生成可读性良好的摘要
     * 
     * @param markdown Markdown格式的文本
     * @param maxLength 摘要最大长度
     * @return 纯文本摘要
     */
    public String generateSummary(String markdown, int maxLength) {
        if (markdown == null || markdown.isEmpty()) {
            return "";
        }
        
        // 使用CommonMark的TextContentRenderer将Markdown转换为纯文本
        Node document = parser.parse(markdown);
        String plainText = textRenderer.render(document);
        
        // 进一步清理文本
        plainText = cleanupText(plainText);
        
        // 智能截断
        return smartTruncate(plainText, maxLength);
    }
    
    /**
     * 清理文本，去除多余的空白字符和特殊符号
     */
    private String cleanupText(String text) {
        if (text == null) {
            return "";
        }
        
        // 去除多余的换行符和空白字符
        text = text.replaceAll("\\s+", " ");
        
        // 去除可能残留的Markdown符号
        text = text.replaceAll("[#*`_~\\[\\](){}]", "");
        
        // 去除HTML标签（防止意外的HTML内容）
        text = text.replaceAll("<[^>]+>", "");
        
        // 去除多余的标点符号
        text = text.replaceAll("[|>]+", "");
        
        // 清理首尾空白
        return text.trim();
    }
    
    /**
     * 智能截断文本，避免在单词中间截断
     */
    private String smartTruncate(String text, int maxLength) {
        if (text == null || text.length() <= maxLength) {
            return text;
        }
        
        // 在maxLength附近寻找合适的截断点
        int truncatePoint = maxLength;
        
        // 向前寻找句号、感叹号、问号等句子结束符
        for (int i = Math.min(maxLength, text.length() - 1); i >= maxLength * 0.7; i--) {
            char c = text.charAt(i);
            if (c == '。' || c == '！' || c == '？' || c == '.' || c == '!' || c == '?') {
                truncatePoint = i + 1;
                break;
            }
        }
        
        // 如果没找到句子结束符，寻找逗号或空格
        if (truncatePoint == maxLength) {
            for (int i = Math.min(maxLength, text.length() - 1); i >= maxLength * 0.8; i--) {
                char c = text.charAt(i);
                if (c == '，' || c == '、' || c == ',' || c == ' ') {
                    truncatePoint = i;
                    break;
                }
            }
        }
        
        String result = text.substring(0, Math.min(truncatePoint, text.length())).trim();
        
        // 如果截断了内容，添加省略号
        if (truncatePoint < text.length()) {
            result += "...";
        }
        
        return result;
    }
}